// CommentController.js - 评论控制器
const Comment = require('../models/Comment');

/**
 * 评论控制器类
 * 处理用户评论相关的请求
 */
class CommentController {
  /**
   * 创建评论
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async createComment(req, res) {
    try {
      const { videoId, content, parentId = null } = req.body;
      const userId = req.user.id;
      
      // 验证参数
      if (!videoId || !content) {
        return res.status(400).json({
          code: 400,
          message: '请提供视频ID和评论内容',
          data: null
        });
      }
      
      if (content.trim().length === 0) {
        return res.status(400).json({
          code: 400,
          message: '评论内容不能为空',
          data: null
        });
      }
      
      // 验证父评论是否存在（如果提供了parentId）
      if (parentId) {
        const parentComment = await Comment.model.findByPk(parentId);
        if (!parentComment) {
          return res.status(400).json({
            code: 400,
            message: '回复的评论不存在',
            data: null
          });
        }
        
        // 确保父评论属于同一个视频
        if (parentComment.video_id !== videoId) {
          return res.status(400).json({
            code: 400,
            message: '回复的评论与视频不匹配',
            data: null
          });
        }
      }
      
      // 创建评论
      const commentData = {
        user_id: userId,
        video_id: videoId,
        content: content.trim(),
        parent_id: parentId,
        status: 1,
        like_count: 0
      };
      
      const comment = await Comment.create(commentData);
      
      // 获取完整的评论信息（包含用户信息）
      const query = `
        SELECT 
          c.id, 
          c.content, 
          c.like_count, 
          c.status, 
          c.user_id, 
          c.video_id, 
          c.parent_id, 
          c.created_at, 
          c.updated_at,
          u.username, 
          u.nickname, 
          u.avatar
        FROM comments c
        LEFT JOIN users u ON c.user_id = u.id
        WHERE c.id = :commentId
      `;
      
      const [createdComment] = await Comment.model.sequelize.query(query, {
        replacements: { commentId: comment.id },
        type: Comment.model.sequelize.QueryTypes.SELECT
      });
      
      res.status(201).json({
        code: 201,
        message: '评论成功',
        data: createdComment
      });
    } catch (error) {
      console.error('创建评论失败:', error);
      res.status(500).json({
        code: 500,
        message: '评论失败，请稍后重试',
        data: null
      });
    }
  }

  /**
   * 删除评论
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async deleteComment(req, res) {
    try {
      const { commentId } = req.params;
      const userId = req.user.id;
      
      // 验证参数
      if (!commentId) {
        return res.status(400).json({
          code: 400,
          message: '请提供评论ID',
          data: null
        });
      }
      
      // 删除评论（会验证是否是用户自己的评论）
      const result = await Comment.destroy(parseInt(commentId), userId);
      
      if (result === 0) {
        return res.status(403).json({
          code: 403,
          message: '删除失败，您无权删除该评论',
          data: null
        });
      }
      
      res.status(200).json({
        code: 200,
        message: '评论删除成功',
        data: null
      });
    } catch (error) {
      console.error('删除评论失败:', error);
      res.status(500).json({
        code: 500,
        message: '删除评论失败，请稍后重试',
        data: null
      });
    }
  }

  /**
   * 获取视频评论列表
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getVideoComments(req, res) {
    try {
      const { videoId } = req.params;
      const { page = 1, pageSize = 10 } = req.query;
      
      // 验证参数
      if (!videoId) {
        return res.status(400).json({
          code: 400,
          message: '请提供视频ID',
          data: null
        });
      }
      
      const pageNum = parseInt(page, 10) || 1;
      const size = parseInt(pageSize, 10) || 10;
      
      // 获取评论列表
      const comments = await Comment.getVideoComments(parseInt(videoId), pageNum, size);
      
      // 获取评论总数
      const total = await Comment.getCommentsCount(parseInt(videoId));
      
      res.status(200).json({
        code: 200,
        message: '获取评论列表成功',
        data: {
          list: comments,
          page: pageNum,
          pageSize: size,
          total,
          totalPages: Math.ceil(total / size)
        }
      });
    } catch (error) {
      console.error('获取评论列表失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取评论列表失败，请稍后重试',
        data: null
      });
    }
  }

  /**
   * 点赞评论
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async likeComment(req, res) {
    try {
      const { commentId } = req.params;
      
      // 验证参数
      if (!commentId) {
        return res.status(400).json({
          code: 400,
          message: '请提供评论ID',
          data: null
        });
      }
      
      // 验证评论是否存在
      const comment = await Comment.model.findByPk(parseInt(commentId));
      if (!comment) {
        return res.status(404).json({
          code: 404,
          message: '评论不存在',
          data: null
        });
      }
      
      // 点赞评论
      const likeCount = await Comment.likeComment(parseInt(commentId));
      
      res.status(200).json({
        code: 200,
        message: '点赞成功',
        data: {
          commentId: parseInt(commentId),
          likeCount: likeCount
        }
      });
    } catch (error) {
      console.error('点赞评论失败:', error);
      res.status(500).json({
        code: 500,
        message: '点赞评论失败，请稍后重试',
        data: null
      });
    }
  }
}

module.exports = CommentController;